package controllers

import (
	"net/http"

	"WHY_GIN/schedule"
	"github.com/gin-gonic/gin"
)

// SchedulerController 调度器控制器
type SchedulerController struct {
	schedulerManager *schedule.SchedulerManager
	takeProfitController *TakeProfitController
}

// NewSchedulerController 创建新的调度器控制器
func NewSchedulerController() *SchedulerController {
	return &SchedulerController{
		schedulerManager: schedule.NewSchedulerManager(),
		takeProfitController: NewTakeProfitController(),
	}
}

// DogeStartRequest DOGE调度器启动请求参数
type DogeStartRequest struct {
	GridMode         string  `json:"grid_mode"`          // 网格模式："fixed" 或 "smart"，默认"smart"
	FixedGridPercent float64 `json:"fixed_grid_percent"` // 固定网格间距（仅在固定模式下使用），范围0.001-0.1（0.1%-10%）
	UsdtAmount       float64 `json:"usdt_amount"`        // 每次交易的USDT金额，默认40.0，最小20.0
	GridLevels       int     `json:"grid_levels"`        // 网格层级数量，默认5，范围1-10
}

// StartDogeScheduler 启动DOGE交易调度器
// @Summary 启动DOGE交易调度器
// @Description 启动DOGE/USDT网格交易调度器，支持固定网格模式和智能网格模式，根据grid_mode参数选择模式，可配置每次交易的USDT金额和网格层级数量
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Param request body DogeStartRequest false "启动参数（grid_mode: 网格模式, fixed_grid_percent: 固定网格间距, usdt_amount: 每次交易USDT金额, grid_levels: 网格层级数量）"
// @Success 200 {object} map[string]interface{} "启动成功"
// @Failure 400 {object} map[string]interface{} "启动失败"
// @Router /api/scheduler/doge/start [post]
func (sc *SchedulerController) StartDogeScheduler(c *gin.Context) {
	// 解析请求参数
	var req DogeStartRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		// 如果没有提供参数或参数格式错误，使用默认智能模式
		req.GridMode = "smart"
	}

	// 参数验证和默认值设置
	if req.GridMode == "" {
		req.GridMode = "smart" // 默认智能模式
	}

	// 验证网格模式
	if req.GridMode != "fixed" && req.GridMode != "smart" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"message": "无效的网格模式",
			"error":   "grid_mode必须是'fixed'或'smart'",
		})
		return
	}

	// 固定模式参数验证
	if req.GridMode == "fixed" {
		if req.FixedGridPercent <= 0 || req.FixedGridPercent > 0.1 {
			c.JSON(http.StatusBadRequest, gin.H{
				"success": false,
				"message": "固定网格间距参数错误",
				"error":   "fixed_grid_percent必须在0.001-0.1之间（0.1%-10%）",
			})
			return
		}
	}

	// USDT交易金额参数验证
	if req.UsdtAmount > 0 && req.UsdtAmount < 20.0 {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"message": "交易金额参数错误",
			"error":   "usdt_amount必须大于等于20 USDT",
		})
		return
	}

	// 网格层级参数验证
	if req.GridLevels > 0 && (req.GridLevels < 1 || req.GridLevels > 10) {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"message": "网格层级参数错误",
			"error":   "grid_levels必须在1-10之间",
		})
		return
	}

	// 构建调度器配置
	config := schedule.DogeSchedulerConfig{
		GridMode:         schedule.GridMode(req.GridMode),
		FixedGridPercent: req.FixedGridPercent,
		UsdtAmount:       req.UsdtAmount,
		GridLevels:       req.GridLevels,
	}

	// 启动调度器
	err := sc.schedulerManager.StartDogeSchedulerWithConfig(config)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"message": "启动DOGE调度器失败",
			"error":   err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "DOGE调度器启动成功",
		"data":    sc.schedulerManager.GetDogeSchedulerStatus(),
	})
}

// StopDogeScheduler 停止DOGE交易调度器
// @Summary 停止DOGE交易调度器
// @Description 停止DOGE/USDT交易对的定时交易调度器
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{} "停止成功"
// @Router /api/scheduler/doge/stop [post]
func (sc *SchedulerController) StopDogeScheduler(c *gin.Context) {
	sc.schedulerManager.StopDogeScheduler()

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "DOGE调度器已停止",
		"data":    sc.schedulerManager.GetDogeSchedulerStatus(),
	})
}

// GetDogeSchedulerStatus 获取DOGE调度器状态
// @Summary 获取DOGE调度器状态
// @Description 获取DOGE/USDT交易调度器的当前运行状态和配置信息
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{} "状态信息"
// @Router /api/scheduler/doge/status [get]
func (sc *SchedulerController) GetDogeSchedulerStatus(c *gin.Context) {
	status := sc.schedulerManager.GetDogeSchedulerStatus()

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "获取状态成功",
		"data":    status,
	})
}

// StartTrxScheduler 启动TRX交易调度器
// @Summary 启动TRX交易调度器
// @Description 启动TRX/USDT交易对的定时交易调度器，每1秒检查一次交易条件
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{} "启动成功"
// @Failure 400 {object} map[string]interface{} "启动失败"
// @Router /api/scheduler/trx/start [post]
func (sc *SchedulerController) StartTrxScheduler(c *gin.Context) {
	err := sc.schedulerManager.StartTrxScheduler()
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"message": "启动TRX调度器失败",
			"error":   err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "TRX调度器启动成功",
		"data":    sc.schedulerManager.GetTrxSchedulerStatus(),
	})
}

// StopTrxScheduler 停止TRX交易调度器
// @Summary 停止TRX交易调度器
// @Description 停止TRX/USDT交易对的定时交易调度器
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{} "停止成功"
// @Router /api/scheduler/trx/stop [post]
func (sc *SchedulerController) StopTrxScheduler(c *gin.Context) {
	sc.schedulerManager.StopTrxScheduler()

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "TRX调度器已停止",
		"data":    sc.schedulerManager.GetTrxSchedulerStatus(),
	})
}

// GetTrxSchedulerStatus 获取TRX调度器状态
// @Summary 获取TRX调度器状态
// @Description 获取TRX/USDT交易调度器的当前运行状态和配置信息
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{} "状态信息"
// @Router /api/scheduler/trx/status [get]
func (sc *SchedulerController) GetTrxSchedulerStatus(c *gin.Context) {
	status := sc.schedulerManager.GetTrxSchedulerStatus()

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "获取TRX状态成功",
		"data":    status,
	})
}

// GetAllSchedulersStatus 获取所有调度器状态
// @Summary 获取所有调度器状态
// @Description 获取系统中所有交易调度器的状态信息
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{} "所有调度器状态"
// @Router /api/scheduler/status [get]
func (sc *SchedulerController) GetAllSchedulersStatus(c *gin.Context) {
	status := sc.schedulerManager.GetAllSchedulersStatus()

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "获取所有调度器状态成功",
		"data":    status,
	})
}

// StopAllSchedulers 停止所有调度器
// @Summary 停止所有调度器
// @Description 停止系统中所有正在运行的交易调度器
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{} "停止成功"
// @Router /api/scheduler/stop-all [post]
func (sc *SchedulerController) StopAllSchedulers(c *gin.Context) {
	sc.schedulerManager.StopAllSchedulers()

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "所有调度器已停止",
		"data":    sc.schedulerManager.GetAllSchedulersStatus(),
	})
}

// GetDogeBuyPauseStatus 获取DOGE调度器买单暂停状态
// @Summary 获取DOGE调度器买单暂停状态
// @Description 获取DOGE交易调度器的买单暂停状态信息，包括是否暂停、暂停开始时间、剩余时间等
// @Tags 调度器管理
// @Produce json
// @Success 200 {object} map[string]interface{} "获取成功"
// @Failure 400 {object} map[string]interface{} "获取失败"
// @Router /api/scheduler/doge/buy-pause-status [get]
func (sc *SchedulerController) GetDogeBuyPauseStatus(c *gin.Context) {
	status, err := sc.schedulerManager.GetDogeBuyPauseStatus()
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"message": "获取买单暂停状态失败",
			"error":   err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "获取买单暂停状态成功",
		"data":    status,
	})
}

// ResumeDogeBuyOrders 手动恢复DOGE调度器买单
// @Summary 手动恢复DOGE调度器买单
// @Description 手动恢复DOGE交易调度器的买单功能，解除因止损事件导致的买单暂停
// @Tags 调度器管理
// @Produce json
// @Success 200 {object} map[string]interface{} "恢复成功"
// @Failure 400 {object} map[string]interface{} "恢复失败"
// @Router /api/scheduler/doge/resume-buy-orders [post]
func (sc *SchedulerController) ResumeDogeBuyOrders(c *gin.Context) {
	err := sc.schedulerManager.ResumeDogeBuyOrders()
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"message": "恢复买单失败",
			"error":   err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "买单已恢复",
	})
}

// GetTakeProfitController 获取止盈控制器
func (sc *SchedulerController) GetTakeProfitController() *TakeProfitController {
	return sc.takeProfitController
}

// StartTakeProfitStrategy 启动止盈策略
// @Summary 启动止盈策略
// @Description 启动止盈策略监控，支持压力位突破和分批卖出
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Param request body StartTakeProfitRequest false "止盈策略启动参数"
// @Success 200 {object} map[string]interface{} "启动成功"
// @Failure 400 {object} map[string]interface{} "启动失败"
// @Router /api/scheduler/take-profit/start [post]
func (sc *SchedulerController) StartTakeProfitStrategy(c *gin.Context) {
	sc.takeProfitController.StartTakeProfitMonitoring(c)
}

// StopTakeProfitStrategy 停止止盈策略
// @Summary 停止止盈策略
// @Description 停止止盈策略监控
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{} "停止成功"
// @Failure 400 {object} map[string]interface{} "停止失败"
// @Router /api/scheduler/take-profit/stop [post]
func (sc *SchedulerController) StopTakeProfitStrategy(c *gin.Context) {
	sc.takeProfitController.StopTakeProfitMonitoring(c)
}

// GetTakeProfitStatus 获取止盈策略状态
// @Summary 获取止盈策略状态
// @Description 获取止盈策略的当前运行状态和配置信息
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{} "状态信息"
// @Router /api/scheduler/take-profit/status [get]
func (sc *SchedulerController) GetTakeProfitStatus(c *gin.Context) {
	sc.takeProfitController.GetTakeProfitStatus(c)
}

// SetTakeProfitResistanceLevel 设置止盈压力位
// @Summary 设置止盈压力位
// @Description 为指定交易对设置压力位价格，用于触发止盈策略
// @Tags 调度器管理
// @Accept json
// @Produce json
// @Param request body SetResistanceLevelRequest true "压力位设置参数"
// @Success 200 {object} map[string]interface{} "设置成功"
// @Failure 400 {object} map[string]interface{} "设置失败"
// @Router /api/scheduler/take-profit/resistance-level [post]
func (sc *SchedulerController) SetTakeProfitResistanceLevel(c *gin.Context) {
	sc.takeProfitController.SetResistanceLevel(c)
}